import isEmpty from 'loadsh/isEmpty'
import compact from 'loadsh/compact'
import {
  GetOrderManagementInfo,
  PostDeleteData,
  PostOrderManagementInfo
} from '/constData/requestFun/_httpRequest';
import {
  ApproveNewOrder,
  GetOrder,
  GetOrderById,
  GetOrderManagement,
  GetOrderManagementById,
  GetReturnDocx,
  GetUserInfo,
  OrderDeleteData,
  OrderManagementDeleteData,
  PostOrder,
  PostOrderManagement,
  PutOrder
} from '/constData/requestFun/_teseRequest';
import {
  GetUserInfoFiled
} from '/constData/requestFun/_utils';
import {
  LOG
} from '/constData/_';
Page({
  data: {
    item: 1,
    min: null,
    max: new Date('2033/12/02'),
    defaultDate: new Date(),
    defaultValue: '设备A',
    list: ['设备A', '设备B', '设备C', '设备D'],
    id: '', //订单id
    OrderInfo: {
      CorpId: '', //申请人
      Numbering: '', //编号
      WorkNumber: '', //随工单号
      CustomerName: '', //客户名称
      CommissionEngineers: '', //委托工程师
      ContactNumber: '', //联系电话
      ProductsNumber: '', //产品数量
      ProductsName: '', //产品名称
      ProductsModel: '', //产品型号
      ProductsLots: '', //产品批次
      FormFactor: '', //封装形式
      Scene: '是', //现场
      Urgency: '正常', //紧急程度
      CompletionTime: new Date(), //完成时间
      // EstimatedTime:new Date(),//预计最终完成时间
      Temperature: '', //温度
      Humidity: '', //湿度
      Items: [{
        // EstimatedTime:new Date(),
        // ReasonExtension:'',
        // FinalTime:new Date(),
        TestResult:'',
        SampleNumber:'',
        Project: '',
        Condition: '',
        Engineer: '',
        DisEngineer: '',
        Quantity: '',
        DeviceNumber: '',
        StartTime: '',
        EndTime: '',
        TrialTime: '',
        Sign: '',
        operate: '',
        info: '',
        annex: '',
        totalTime: '',
      }], //试验
      Laboratory: '是', //是否留着实验室
      Fabricated: '', //拟制
      Review: '', //复核
      // ProposedDate:new Date(),
      // ReviewDate:new Date(),
      totalTime: '',
      TotalPrice:'',//总价
    },
    options: [{
        value: '是',
        label: '是'
      },
      {
        value: '否',
        label: '否'
      },
    ],
    options1: [{
        value: '正常',
        label: '正常'
      },
      {
        value: '紧急',
        label: '紧急'
      },
    ],
    options2: [{
        value: '是',
        label: '是'
      },
      {
        value: '否',
        label: '否'
      },
    ],
    ReceiveData: [],
  },

  TrialAddProject() {
    const newInput = {
      Project: '',
      Condition: '',
      Engineer: '',
      DisEngineer: '',
      Quantity: '',
      DeviceNumber: '',
      StartTime: '',
      EndTime: '',
      TrialTime: '',
      Sign: '',
    };
    this.setData({
      ...this.data.OrderInfo,
      OrderInfo: {
        ...this.data.OrderInfo,
        Items: [...this.data.OrderInfo.Items, newInput],
      }

    })
  },
  OnNumberingChange(value) {
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        Numbering: value
      }
    })
  },
  OnWorkNumberChange(value) {
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        WorkNumber: value
      }
    })
  },
  OnCustomerNameChange(value) {
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        CustomerName: value
      }
    })
  },
  OnCommissionEngineersChange(value) {
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        CommissionEngineers: value
      }
    })
  },
  OnContactNumberChange(value) {
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        ContactNumber: value
      }
    })
  },
  OnProductsNumberChange(value) {
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        ProductsNumber: value
      }
    })
  },
  OnProductsNameChange(value) {
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        ProductsName: value
      }
    })
  },
  OnProductsModelChange(value) {
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        ProductsModel: value
      }
    })
  },
  OnProductsLotsChange(value) {
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        ProductsLots: value
      }
    })
  },
  OnFormFactorChange(value) {
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        FormFactor: value
      }
    })
  },
  OnTemperatureChange(value) {
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        Temperature: value
      }
    })
  },
  OnHumidityChange(value) {
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        Humidity: value
      }
    })
  },
  SceneChange(value) {
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        Scene: value
      }
    })
  },
  UrgencyChange(value) {
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        Urgency: value
      }
    })
  },
  OnFabricatedChange(value, e) {
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        Fabricated: value
      }
    })
  },
  OnTotalTimeChange(value, e) {
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        totalTime: value
      }
    })
  },
  OnTotalPriceChange(value, e) {
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        TotalPrice: value
      }
    })
  },
  OnProjectChange(value, e) {
    const trials = this.data.OrderInfo.Items; // 获取当前的试验列表  
    // // 使用索引来更新Trial数组中的对应元素  
    trials[e.currentTarget.dataset.index].project = value; // 索引从1开始，但数组索引从0开始，所以需要减1  
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        Items: trials // 设置更新后的试验列表  
      }
    });
  },
  OnConditionChange(value, e) {
    const trials = this.data.OrderInfo.Items; // 获取当前的试验列表  
    // // 使用索引来更新Trial数组中的对应元素  
    trials[e.currentTarget.dataset.index].condition = value; // 索引从1开始，但数组索引从0开始，所以需要减1  
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        Items: trials // 设置更新后的试验列表  
      }
    });
  },
  OnEngineerChange(value, e) {
    const trials = this.data.OrderInfo.Items; // 获取当前的试验列表  
    // // 使用索引来更新Trial数组中的对应元素  
    trials[e.currentTarget.dataset.index].engineer = value; // 索引从1开始，但数组索引从0开始，所以需要减1  
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        Items: trials // 设置更新后的试验列表  
      }
    });
  },
  onEngineerAdd(e) {
    const trials = this.data.OrderInfo.Items; // 获取当前的试验列表 
    // @ts-ignore
    my.complexChoose({
      title: "选择人", //标题
      multiple: true, //是否多选
      maxUsers: 1000, //最大可选人数
      responseUserOnly: true, //返回人，或者返回人和部门
      success: (res) => {
        console.log('res', res.users[0].userId)
        trials[e.currentTarget.dataset.index].Engineer = res.users[0].userId; // 索引从1开始，但数组索引从0开始，所以需要减1  
        trials[e.currentTarget.dataset.index].DisEngineer = res.users;
        this.setData({
          OrderInfo: {
            ...this.data.OrderInfo,
            Items: trials // 设置更新后的试验列表  
          }
        });
      }
    })
  },
  OnQuantityChange(value, e) {
    const trials = this.data.OrderInfo.Items; // 获取当前的试验列表  
    // // 使用索引来更新Trial数组中的对应元素  
    trials[e.currentTarget.dataset.index].quantity = value; // 索引从1开始，但数组索引从0开始，所以需要减1  
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        Items: trials // 设置更新后的试验列表  
      }
    });
  },
  OnDeviceNumberChange(value, e) {
    const trials = this.data.OrderInfo.Items; // 获取当前的试验列表  
    // // 使用索引来更新Trial数组中的对应元素  
    trials[e.currentTarget.dataset.index].deviceNumber = value; // 索引从1开始，但数组索引从0开始，所以需要减1  
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        Items: trials // 设置更新后的试验列表  
      }
    });
  },
  OnOperateChange(value, e) {
    const trials = this.data.OrderInfo.Items; // 获取当前的试验列表  
    // // 使用索引来更新Trial数组中的对应元素  
    trials[e.currentTarget.dataset.index].operate = value; // 索引从1开始，但数组索引从0开始，所以需要减1  
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        Items: trials // 设置更新后的试验列表  
      }
    });
  },
  OnInfoChange(value, e) {
    const trials = this.data.OrderInfo.Items; // 获取当前的试验列表  
    // // 使用索引来更新Trial数组中的对应元素  
    trials[e.currentTarget.dataset.index].info = value; // 索引从1开始，但数组索引从0开始，所以需要减1  
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        Items: trials // 设置更新后的试验列表  
      }
    });
  },
  OntotalTimeChange(value, e) {
    const trials = this.data.OrderInfo.Items; // 获取当前的试验列表  
    // // 使用索引来更新Trial数组中的对应元素  
    trials[e.currentTarget.dataset.index].totalTime = value; // 索引从1开始，但数组索引从0开始，所以需要减1  
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        Items: trials // 设置更新后的试验列表  
      }
    });
  },
  EstimatedTime(date, format, e) {
    const trials = this.data.OrderInfo.Items; // 获取当前的试验列表  
    // // 使用索引来更新Trial数组中的对应元素  
    trials[e.currentTarget.dataset.index].estimatedTime = date; // 索引从1开始，但数组索引从0开始，所以需要减1  
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        Items: trials // 设置更新后的试验列表  
      }
    });
  },
  OnReasonExtensionChange(value, e) {
    const trials = this.data.OrderInfo.Items; // 获取当前的试验列表  
    // // 使用索引来更新Trial数组中的对应元素  
    trials[e.currentTarget.dataset.index].reasonExtension = value; // 索引从1开始，但数组索引从0开始，所以需要减1  
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        Items: trials // 设置更新后的试验列表  
      }
    });
  },
  FinalTime(date, format, e) {
    const trials = this.data.OrderInfo.Items; // 获取当前的试验列表  
    // // 使用索引来更新Trial数组中的对应元素  
    trials[e.currentTarget.dataset.index].finalTime = date; // 索引从1开始，但数组索引从0开始，所以需要减1  
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        Items: trials // 设置更新后的试验列表  
      }
    });
  },
  OnSampleNumberChange(value, e) {
    const trials = this.data.OrderInfo.Items; // 获取当前的试验列表  
    // // 使用索引来更新Trial数组中的对应元素  
    trials[e.currentTarget.dataset.index].sampleNumber = value; // 索引从1开始，但数组索引从0开始，所以需要减1  
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        Items: trials // 设置更新后的试验列表  
      }
    });
  },
  OnTestResultChange(value, e) {
    const trials = this.data.OrderInfo.Items; // 获取当前的试验列表  
    // // 使用索引来更新Trial数组中的对应元素  
    trials[e.currentTarget.dataset.index].testResult = value; // 索引从1开始，但数组索引从0开始，所以需要减1  
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        Items: trials // 设置更新后的试验列表  
      }
    });
  },
  StartTimeOk(date, format, e) {
    const trials = this.data.OrderInfo.Items; // 获取当前的试验列表  
    // // 使用索引来更新Trial数组中的对应元素  
    trials[e.currentTarget.dataset.index].startTime = date; // 索引从1开始，但数组索引从0开始，所以需要减1  
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        Items: trials // 设置更新后的试验列表  
      }
    });
  },
  EndTimeOk(date, format, e) {
    const trials = this.data.OrderInfo.Items; // 获取当前的试验列表  
    // // 使用索引来更新Trial数组中的对应元素  
    trials[e.currentTarget.dataset.index].endTime = date; // 索引从1开始，但数组索引从0开始，所以需要减1  
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        Items: trials // 设置更新后的试验列表  
      }
    });
  },
  FinishTimeOk(date, format, e) {
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        CompletionTime: date
      }
    })
  },
  EstimatedTimeOk(date, format, e) {
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        EstimatedTime: date
      }
    })
  },
  ProposedDate(date, format, e) {
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        ProposedDate: date
      }
    })
  },
  ReviewDate(date, format, e) {
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        ReviewDate: date
      }
    })
  },
  Delete(e) {
    const id = e.currentTarget.dataset.id
    OrderDeleteData(id, (res) => {
      my.alert({
        title: '撤销成功',
      });
      //刷新数据
      this.setData({
        ReceiveData: this.data.ReceiveData.filter((it) => {
          return it.item1.id !== id
        })
      })
    }, (err) => {
      my.alert({
        title: '撤销失败',
      });
    })
  },
  ReturnDocx(e) {
    const id = e.currentTarget.dataset.id
    GetReturnDocx(id, (res) => {
      console.log('文件下载成功');
    });
  },
  // 上传数据
  onSubmit(e) {
    console.log('id', this.data.id);
    // if (this.data.OrderInfo && 'id' in this.data.OrderInfo) {
    //   delete this.data.OrderInfo.id;
    // }
    console.log('提交数据', JSON.stringify(this.data.OrderInfo));
    ApproveNewOrder(JSON.stringify(this.data.OrderInfo), (res) => {
      my.alert({
        title: '提交成功',
      });
      GetOrder((res)=>{
        const Aprrove=res.data
        .filter(it=>(it.item1.completeOrderId === '0' && it.item1.startApprove))
        this.setData({
          ReceiveData: [...this.data.ReceiveData, Aprrove].reverse()
        })
      })
      //清除填写数据
      this.setData({
        OrderInfo: {
          ...this.data.OrderInfo,
          Numbering: '', //编号
          WorkNumber: '', //随工单号
          CustomerName: '', //客户名称
          CommissionEngineers: '', //委托工程师
          ContactNumber: '', //联系电话
          ProductsNumber: '', //产品数量
          ProductsName: '', //产品名称
          ProductsModel: '', //产品型号
          ProductsLots: '', //产品批次
          FormFactor: '', //封装形式
          Scene: '是', //现场
          Urgency: '正常', //紧急程度
          CompletionTime: new Date(), //完成时间
          // EstimatedTime:new Date(),//预计最终完成时间
          Temperature: '', //温度
          Humidity: '', //湿度
          Items: [{
            // EstimatedTime:new Date(),
            // ReasonExtension:'',
            // FinalTime:new Date(),
            TestResult:'',
            SampleNumber:'',
            Project: '',
            Condition: '',
            Engineer: '',
            DisEngineer: '',
            Quantity: '',
            DeviceNumber: '',
            StartTime: '',
            EndTime: '',
            TrialTime: '',
            Sign: '',
            operate: '',
            info: '',
            annex: '',
            totalTime: '',
          }], //试验
          Laboratory: '是', //是否留着实验室
          Fabricated: '', //拟制
          Review: '', //复核
          // ProposedDate:new Date(),
          // ReviewDate:new Date(),
          totalTime: '',
          TotalPrice:'',//总价
        },
      })
    })
  },
  //获取数据
  onLoad(e) {
    // console.log('SSS', e);
    this.setData({
      id: e.id
    })
    // console.log('ID',this.data.id);
    const id = e.id
    if (!id) {
      //获取订单数据
      GetOrder((res)=>{
        const Aprrove=res.data
        .filter(it=>(it.item1.completeOrderId === '0' && it.item1.startApprove))
        this.setData({
          ReceiveData: [...this.data.ReceiveData, Aprrove].reverse()
        })
        console.log('ReceiveData',this.data.ReceiveData);
      })
    } else {
      my.getStorage({
        key: 'userInfo',
        success: (storage) => {
          new Promise((resolve)=>{
            GetOrderById(id, (orderResponse) => {
              const dataItem = orderResponse.data;
              // 遍历items数组并累加totalTime  
              // 初始化totalItemsTime为0  
              let totalItemsTime = 0;
              orderResponse.data.items.forEach(item => {
                // 如果item的totalTime还未计算，则现在计算它  
                if (!item.totalTime) {
                  item.totalTime = calculateTimeDiff(item.startTime, item.endTime);
                }
                // 累加totalTime到totalItemsTime  
                totalItemsTime += item.totalTime;
              });
              this.setData({
                OrderInfo: {
                  ...this.data.OrderInfo,
                  CorpId: storage.data.result.userid,
                  Numbering: dataItem.numbering,
                  WorkNumber: dataItem.workNumber,
                  CustomerName: dataItem.customerName,
                  CommissionEngineers: dataItem.commissionEngineers,
                  ContactNumber: dataItem.contactNumber,
                  ProductsNumber: dataItem.productsNumber,
                  ProductsName: dataItem.productsName,
                  ProductsModel: dataItem.productsModel,
                  ProductsLots: dataItem.productsLots,
                  FormFactor: dataItem.formFactor,
                  Scene: dataItem.scene,
                  Urgency: dataItem.urgency,
                  CompletionTime: new Date(dataItem.completionTime), // 将字符串转换为Date对象  
                  // EstimatedTime: new Date(dataItem.estimatedTime), 
                  Temperature: dataItem.temperature,
                  Humidity: dataItem.humidity,
                  Items: dataItem.items.map((it) => {
                    it.totalTime = calculateTimeDiff(it.startTime, it.endTime)
                    return it
                  }), // 假设 items 已经是正确的格式  
                  Laboratory: dataItem.laboratory,
                  Fabricated: dataItem.fabricated,
                  Review: dataItem.review,
                  // ProposedDate:new Date(dataItem.proposedDate),
                  // ReviewDate:new Date(dataItem.reviewDate), 
                  totalTime: totalItemsTime,
                }
              });
              resolve();
            });
          }).then((res)=>{
            GetOrder((res)=>{
              const Aprrove=res.data
              .filter(it=>(it.item1.completeOrderId === '0' && it.item1.startApprove))
              this.setData({
                ReceiveData: [...this.data.ReceiveData, Aprrove].reverse()
              })
              console.log('ReceiveData2',this.data.ReceiveData);
            })
            console.log('resss',res);
          })
        }
      })
    }
  },
  // 选择操作人
  Operators() {
    my.complexChoose({
      title: "测试标题", //标题
      multiple: true, //是否多选
      limitTips: "超出了", //超过限定人数返回提示
      maxUsers: 1000, //最大可选人数
      responseUserOnly: true, //返回人，或者返回人和部门
      success: (res) => {
        console.log('res', res);
        this.setData({
          OrderInfo: {
            ...this.data.OrderInfo,
            EquipmentInvolved: [],
          }
        })
        for (let index = 0; index < res.users.length; index++) {
          this.setData({
            OrderInfo: {
              ...this.data.OrderInfo,
              EquipmentInvolved: [...this.data.OrderInfo.EquipmentInvolved, res.users[index]],
            }
          })
        }
      },
      fail: function (err) {}
    })
  },
  Del(e) {
    const n = e.target.dataset.name
    this.setData({
      OrderInfo: {
        EquipmentInvolved: this.data.OrderInfo.EquipmentInvolved.filter((name) => {
          return name !== n
        })
      }
    })
  },
  PickerhandleOk(value, column, e) {
    const name = e.currentTarget.dataset.name
    const Temp = []
    this.data.OrderInfo.EquipmentInvolved.forEach((it) => {
      if (it.name === name) {
        Temp.push({
          ...it,
          Equipment: value
        })
      } else
        Temp.push({
          ...it
        })
    })
    this.setData({
      OrderInfo: {
        ...this.data.OrderInfo,
        EquipmentInvolved: Temp
      }
    })
  },
});

function calculateTimeDiff(startTimeStr, endTimeStr) {
  // 将字符串时间转换为Date对象  
  const startTime = new Date(startTimeStr);
  const endTime = new Date(endTimeStr);

  // 确保结束时间大于开始时间  
  if (endTime < startTime) {
    throw new Error('结束时间必须大于开始时间');
  }

  // 计算时间差（毫秒）  
  const diffInMilliseconds = endTime - startTime;

  // 将毫秒转换为分钟  
  const diffInMinutes = Math.ceil(diffInMilliseconds / (1000 * 60));

  // 向上取整为半小时的倍数  
  const roundedDiffInMinutes = Math.ceil(diffInMinutes / 30) * 30;

  // 将分钟转换为小时  
  const diffInHours = roundedDiffInMinutes / 60;

  return diffInHours;
}